-------------------------------------------------------------------------------
--
-- | 
-- Module      :  Language.XMLSchema.TermInstances 
-- Copyright   :  (c) Ricardo Vilaça 2005
-- License     :  LGPL
-- 
-- Maintainer  :  joost.visser@di.uminho.pt
-- Stability   :  experimental
-- Portability :  portable
--
-- This module contains the instances definitions for Term and Typeable
-- for the XML Schema abstract syntax of "Language.XMLSchema.Syntax". These instances
-- were generated with DrIFT.
--
-------------------------------------------------------------------------------

module Language.XMLSchema.TermInstances where

import Text.XML.HaXml.OneOfNInstances
import Text.XML.HaXml.Xml2HaskellInstances
import Language.XMLSchema.Syntax
import TermRep


{-% DrIFT (Automatic class derivations for Haskell) %-}
{-* Generated by DrIFT-Strafunksi 1.7 : Look, but Don't Touch. *-}

instance Term Xs'simpleType where
    explode (x::Xs'simpleType) = TermRep (toDyn x, f x, g x) where
	f (Xs'simpleType aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'simpleType _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'simpleType (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'simpleType)

_tc_Xs'simpleTypeTc = mkTyCon "Xs'simpleType"
instance Typeable Xs'simpleType where
    typeOf x = mkTyConApp _tc_Xs'simpleTypeTc [ ]

instance Term Xs'simpleType_Attrs where
    explode (x::Xs'simpleType_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'simpleType_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'simpleType_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'simpleType_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'simpleType_Attrs)

_tc_Xs'simpleType_AttrsTc = mkTyCon "Xs'simpleType_Attrs"
instance Typeable Xs'simpleType_Attrs where
    typeOf x = mkTyConApp _tc_Xs'simpleType_AttrsTc [ ]

instance Term Xs'restriction where
    explode (x::Xs'restriction) = TermRep (toDyn x, f x, g x) where
	f (Xs'restriction aa ab ac ad) = [explode aa,explode ab,explode ac,explode ad]
	g (Xs'restriction _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad] -> toDyn ((Xs'restriction (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad))::Xs'restriction)

_tc_Xs'restrictionTc = mkTyCon "Xs'restriction"
instance Typeable Xs'restriction where
    typeOf x = mkTyConApp _tc_Xs'restrictionTc [ ]

instance Term Xs'restriction_Attrs where
    explode (x::Xs'restriction_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'restriction_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'restriction_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'restriction_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'restriction_Attrs)

_tc_Xs'restriction_AttrsTc = mkTyCon "Xs'restriction_Attrs"
instance Typeable Xs'restriction_Attrs where
    typeOf x = mkTyConApp _tc_Xs'restriction_AttrsTc [ ]

instance Term Xs'list where
    explode (x::Xs'list) = TermRep (toDyn x, f x, g x) where
	f (Xs'list aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'list _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'list (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'list)

_tc_Xs'listTc = mkTyCon "Xs'list"
instance Typeable Xs'list where
    typeOf x = mkTyConApp _tc_Xs'listTc [ ]

instance Term Xs'list_Attrs where
    explode (x::Xs'list_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'list_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'list_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'list_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'list_Attrs)

_tc_Xs'list_AttrsTc = mkTyCon "Xs'list_Attrs"
instance Typeable Xs'list_Attrs where
    typeOf x = mkTyConApp _tc_Xs'list_AttrsTc [ ]

instance Term Xs'union where
    explode (x::Xs'union) = TermRep (toDyn x, f x, g x) where
	f (Xs'union aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'union _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'union (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'union)

_tc_Xs'unionTc = mkTyCon "Xs'union"
instance Typeable Xs'union where
    typeOf x = mkTyConApp _tc_Xs'unionTc [ ]

instance Term Xs'union_Attrs where
    explode (x::Xs'union_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'union_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'union_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'union_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'union_Attrs)

_tc_Xs'union_AttrsTc = mkTyCon "Xs'union_Attrs"
instance Typeable Xs'union_Attrs where
    typeOf x = mkTyConApp _tc_Xs'union_AttrsTc [ ]

instance Term Xs'maxExclusive where
    explode (x::Xs'maxExclusive) = TermRep (toDyn x, f x, g x) where
	f (Xs'maxExclusive aa ab) = [explode aa,explode ab]
	g (Xs'maxExclusive _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'maxExclusive (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'maxExclusive)

_tc_Xs'maxExclusiveTc = mkTyCon "Xs'maxExclusive"
instance Typeable Xs'maxExclusive where
    typeOf x = mkTyConApp _tc_Xs'maxExclusiveTc [ ]

instance Term Xs'maxExclusive_Attrs where
    explode (x::Xs'maxExclusive_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'maxExclusive_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'maxExclusive_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'maxExclusive_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'maxExclusive_Attrs)

_tc_Xs'maxExclusive_AttrsTc = mkTyCon "Xs'maxExclusive_Attrs"
instance Typeable Xs'maxExclusive_Attrs where
    typeOf x = mkTyConApp _tc_Xs'maxExclusive_AttrsTc [ ]

instance Term Xs'maxExclusive_fixed where
    explode (x::Xs'maxExclusive_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'maxExclusive_fixed_true = []
	f Xs'maxExclusive_fixed_false = []
	g Xs'maxExclusive_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'maxExclusive_fixed_true)::Xs'maxExclusive_fixed)
	g Xs'maxExclusive_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'maxExclusive_fixed_false)::Xs'maxExclusive_fixed)

_tc_Xs'maxExclusive_fixedTc = mkTyCon "Xs'maxExclusive_fixed"
instance Typeable Xs'maxExclusive_fixed where
    typeOf x = mkTyConApp _tc_Xs'maxExclusive_fixedTc [ ]

instance Term Xs'minExclusive where
    explode (x::Xs'minExclusive) = TermRep (toDyn x, f x, g x) where
	f (Xs'minExclusive aa ab) = [explode aa,explode ab]
	g (Xs'minExclusive _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'minExclusive (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'minExclusive)

_tc_Xs'minExclusiveTc = mkTyCon "Xs'minExclusive"
instance Typeable Xs'minExclusive where
    typeOf x = mkTyConApp _tc_Xs'minExclusiveTc [ ]

instance Term Xs'minExclusive_Attrs where
    explode (x::Xs'minExclusive_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'minExclusive_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'minExclusive_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'minExclusive_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'minExclusive_Attrs)

_tc_Xs'minExclusive_AttrsTc = mkTyCon "Xs'minExclusive_Attrs"
instance Typeable Xs'minExclusive_Attrs where
    typeOf x = mkTyConApp _tc_Xs'minExclusive_AttrsTc [ ]

instance Term Xs'minExclusive_fixed where
    explode (x::Xs'minExclusive_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'minExclusive_fixed_true = []
	f Xs'minExclusive_fixed_false = []
	g Xs'minExclusive_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'minExclusive_fixed_true)::Xs'minExclusive_fixed)
	g Xs'minExclusive_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'minExclusive_fixed_false)::Xs'minExclusive_fixed)

_tc_Xs'minExclusive_fixedTc = mkTyCon "Xs'minExclusive_fixed"
instance Typeable Xs'minExclusive_fixed where
    typeOf x = mkTyConApp _tc_Xs'minExclusive_fixedTc [ ]

instance Term Xs'maxInclusive where
    explode (x::Xs'maxInclusive) = TermRep (toDyn x, f x, g x) where
	f (Xs'maxInclusive aa ab) = [explode aa,explode ab]
	g (Xs'maxInclusive _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'maxInclusive (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'maxInclusive)

_tc_Xs'maxInclusiveTc = mkTyCon "Xs'maxInclusive"
instance Typeable Xs'maxInclusive where
    typeOf x = mkTyConApp _tc_Xs'maxInclusiveTc [ ]

instance Term Xs'maxInclusive_Attrs where
    explode (x::Xs'maxInclusive_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'maxInclusive_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'maxInclusive_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'maxInclusive_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'maxInclusive_Attrs)

_tc_Xs'maxInclusive_AttrsTc = mkTyCon "Xs'maxInclusive_Attrs"
instance Typeable Xs'maxInclusive_Attrs where
    typeOf x = mkTyConApp _tc_Xs'maxInclusive_AttrsTc [ ]

instance Term Xs'maxInclusive_fixed where
    explode (x::Xs'maxInclusive_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'maxInclusive_fixed_true = []
	f Xs'maxInclusive_fixed_false = []
	g Xs'maxInclusive_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'maxInclusive_fixed_true)::Xs'maxInclusive_fixed)
	g Xs'maxInclusive_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'maxInclusive_fixed_false)::Xs'maxInclusive_fixed)

_tc_Xs'maxInclusive_fixedTc = mkTyCon "Xs'maxInclusive_fixed"
instance Typeable Xs'maxInclusive_fixed where
    typeOf x = mkTyConApp _tc_Xs'maxInclusive_fixedTc [ ]

instance Term Xs'minInclusive where
    explode (x::Xs'minInclusive) = TermRep (toDyn x, f x, g x) where
	f (Xs'minInclusive aa ab) = [explode aa,explode ab]
	g (Xs'minInclusive _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'minInclusive (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'minInclusive)

_tc_Xs'minInclusiveTc = mkTyCon "Xs'minInclusive"
instance Typeable Xs'minInclusive where
    typeOf x = mkTyConApp _tc_Xs'minInclusiveTc [ ]

instance Term Xs'minInclusive_Attrs where
    explode (x::Xs'minInclusive_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'minInclusive_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'minInclusive_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'minInclusive_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'minInclusive_Attrs)

_tc_Xs'minInclusive_AttrsTc = mkTyCon "Xs'minInclusive_Attrs"
instance Typeable Xs'minInclusive_Attrs where
    typeOf x = mkTyConApp _tc_Xs'minInclusive_AttrsTc [ ]

instance Term Xs'minInclusive_fixed where
    explode (x::Xs'minInclusive_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'minInclusive_fixed_true = []
	f Xs'minInclusive_fixed_false = []
	g Xs'minInclusive_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'minInclusive_fixed_true)::Xs'minInclusive_fixed)
	g Xs'minInclusive_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'minInclusive_fixed_false)::Xs'minInclusive_fixed)

_tc_Xs'minInclusive_fixedTc = mkTyCon "Xs'minInclusive_fixed"
instance Typeable Xs'minInclusive_fixed where
    typeOf x = mkTyConApp _tc_Xs'minInclusive_fixedTc [ ]

instance Term Xs'precision where
    explode (x::Xs'precision) = TermRep (toDyn x, f x, g x) where
	f (Xs'precision aa ab) = [explode aa,explode ab]
	g (Xs'precision _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'precision (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'precision)

_tc_Xs'precisionTc = mkTyCon "Xs'precision"
instance Typeable Xs'precision where
    typeOf x = mkTyConApp _tc_Xs'precisionTc [ ]

instance Term Xs'precision_Attrs where
    explode (x::Xs'precision_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'precision_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'precision_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'precision_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'precision_Attrs)

_tc_Xs'precision_AttrsTc = mkTyCon "Xs'precision_Attrs"
instance Typeable Xs'precision_Attrs where
    typeOf x = mkTyConApp _tc_Xs'precision_AttrsTc [ ]

instance Term Xs'precision_fixed where
    explode (x::Xs'precision_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'precision_fixed_true = []
	f Xs'precision_fixed_false = []
	g Xs'precision_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'precision_fixed_true)::Xs'precision_fixed)
	g Xs'precision_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'precision_fixed_false)::Xs'precision_fixed)

_tc_Xs'precision_fixedTc = mkTyCon "Xs'precision_fixed"
instance Typeable Xs'precision_fixed where
    typeOf x = mkTyConApp _tc_Xs'precision_fixedTc [ ]

instance Term Xs'scale where
    explode (x::Xs'scale) = TermRep (toDyn x, f x, g x) where
	f (Xs'scale aa ab) = [explode aa,explode ab]
	g (Xs'scale _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'scale (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'scale)

_tc_Xs'scaleTc = mkTyCon "Xs'scale"
instance Typeable Xs'scale where
    typeOf x = mkTyConApp _tc_Xs'scaleTc [ ]

instance Term Xs'scale_Attrs where
    explode (x::Xs'scale_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'scale_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'scale_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'scale_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'scale_Attrs)

_tc_Xs'scale_AttrsTc = mkTyCon "Xs'scale_Attrs"
instance Typeable Xs'scale_Attrs where
    typeOf x = mkTyConApp _tc_Xs'scale_AttrsTc [ ]

instance Term Xs'scale_fixed where
    explode (x::Xs'scale_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'scale_fixed_true = []
	f Xs'scale_fixed_false = []
	g Xs'scale_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'scale_fixed_true)::Xs'scale_fixed)
	g Xs'scale_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'scale_fixed_false)::Xs'scale_fixed)

_tc_Xs'scale_fixedTc = mkTyCon "Xs'scale_fixed"
instance Typeable Xs'scale_fixed where
    typeOf x = mkTyConApp _tc_Xs'scale_fixedTc [ ]

instance Term Xs'length where
    explode (x::Xs'length) = TermRep (toDyn x, f x, g x) where
	f (Xs'length aa ab) = [explode aa,explode ab]
	g (Xs'length _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'length (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'length)

_tc_Xs'lengthTc = mkTyCon "Xs'length"
instance Typeable Xs'length where
    typeOf x = mkTyConApp _tc_Xs'lengthTc [ ]

instance Term Xs'length_Attrs where
    explode (x::Xs'length_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'length_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'length_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'length_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'length_Attrs)

_tc_Xs'length_AttrsTc = mkTyCon "Xs'length_Attrs"
instance Typeable Xs'length_Attrs where
    typeOf x = mkTyConApp _tc_Xs'length_AttrsTc [ ]

instance Term Xs'length_fixed where
    explode (x::Xs'length_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'length_fixed_true = []
	f Xs'length_fixed_false = []
	g Xs'length_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'length_fixed_true)::Xs'length_fixed)
	g Xs'length_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'length_fixed_false)::Xs'length_fixed)

_tc_Xs'length_fixedTc = mkTyCon "Xs'length_fixed"
instance Typeable Xs'length_fixed where
    typeOf x = mkTyConApp _tc_Xs'length_fixedTc [ ]

instance Term Xs'minLength where
    explode (x::Xs'minLength) = TermRep (toDyn x, f x, g x) where
	f (Xs'minLength aa ab) = [explode aa,explode ab]
	g (Xs'minLength _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'minLength (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'minLength)

_tc_Xs'minLengthTc = mkTyCon "Xs'minLength"
instance Typeable Xs'minLength where
    typeOf x = mkTyConApp _tc_Xs'minLengthTc [ ]

instance Term Xs'minLength_Attrs where
    explode (x::Xs'minLength_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'minLength_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'minLength_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'minLength_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'minLength_Attrs)

_tc_Xs'minLength_AttrsTc = mkTyCon "Xs'minLength_Attrs"
instance Typeable Xs'minLength_Attrs where
    typeOf x = mkTyConApp _tc_Xs'minLength_AttrsTc [ ]

instance Term Xs'minLength_fixed where
    explode (x::Xs'minLength_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'minLength_fixed_true = []
	f Xs'minLength_fixed_false = []
	g Xs'minLength_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'minLength_fixed_true)::Xs'minLength_fixed)
	g Xs'minLength_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'minLength_fixed_false)::Xs'minLength_fixed)

_tc_Xs'minLength_fixedTc = mkTyCon "Xs'minLength_fixed"
instance Typeable Xs'minLength_fixed where
    typeOf x = mkTyConApp _tc_Xs'minLength_fixedTc [ ]

instance Term Xs'maxLength where
    explode (x::Xs'maxLength) = TermRep (toDyn x, f x, g x) where
	f (Xs'maxLength aa ab) = [explode aa,explode ab]
	g (Xs'maxLength _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'maxLength (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'maxLength)

_tc_Xs'maxLengthTc = mkTyCon "Xs'maxLength"
instance Typeable Xs'maxLength where
    typeOf x = mkTyConApp _tc_Xs'maxLengthTc [ ]

instance Term Xs'maxLength_Attrs where
    explode (x::Xs'maxLength_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'maxLength_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'maxLength_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'maxLength_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'maxLength_Attrs)

_tc_Xs'maxLength_AttrsTc = mkTyCon "Xs'maxLength_Attrs"
instance Typeable Xs'maxLength_Attrs where
    typeOf x = mkTyConApp _tc_Xs'maxLength_AttrsTc [ ]

instance Term Xs'maxLength_fixed where
    explode (x::Xs'maxLength_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'maxLength_fixed_true = []
	f Xs'maxLength_fixed_false = []
	g Xs'maxLength_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'maxLength_fixed_true)::Xs'maxLength_fixed)
	g Xs'maxLength_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'maxLength_fixed_false)::Xs'maxLength_fixed)

_tc_Xs'maxLength_fixedTc = mkTyCon "Xs'maxLength_fixed"
instance Typeable Xs'maxLength_fixed where
    typeOf x = mkTyConApp _tc_Xs'maxLength_fixedTc [ ]

instance Term Xs'enumeration where
    explode (x::Xs'enumeration) = TermRep (toDyn x, f x, g x) where
	f (Xs'enumeration aa ab) = [explode aa,explode ab]
	g (Xs'enumeration _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'enumeration (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'enumeration)

_tc_Xs'enumerationTc = mkTyCon "Xs'enumeration"
instance Typeable Xs'enumeration where
    typeOf x = mkTyConApp _tc_Xs'enumerationTc [ ]

instance Term Xs'enumeration_Attrs where
    explode (x::Xs'enumeration_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'enumeration_Attrs aa) = [explode aa]
	g (Xs'enumeration_Attrs _) xs = case TermRep.fArgs xs of [aa] -> toDyn ((Xs'enumeration_Attrs (TermRep.fDyn aa))::Xs'enumeration_Attrs)

_tc_Xs'enumeration_AttrsTc = mkTyCon "Xs'enumeration_Attrs"
instance Typeable Xs'enumeration_Attrs where
    typeOf x = mkTyConApp _tc_Xs'enumeration_AttrsTc [ ]

instance Term Xs'whiteSpace where
    explode (x::Xs'whiteSpace) = TermRep (toDyn x, f x, g x) where
	f (Xs'whiteSpace aa ab) = [explode aa,explode ab]
	g (Xs'whiteSpace _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'whiteSpace (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'whiteSpace)

_tc_Xs'whiteSpaceTc = mkTyCon "Xs'whiteSpace"
instance Typeable Xs'whiteSpace where
    typeOf x = mkTyConApp _tc_Xs'whiteSpaceTc [ ]

instance Term Xs'whiteSpace_Attrs where
    explode (x::Xs'whiteSpace_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'whiteSpace_Attrs aa) = [explode aa]
	g (Xs'whiteSpace_Attrs _) xs = case TermRep.fArgs xs of [aa] -> toDyn ((Xs'whiteSpace_Attrs (TermRep.fDyn aa))::Xs'whiteSpace_Attrs)

_tc_Xs'whiteSpace_AttrsTc = mkTyCon "Xs'whiteSpace_Attrs"
instance Typeable Xs'whiteSpace_Attrs where
    typeOf x = mkTyConApp _tc_Xs'whiteSpace_AttrsTc [ ]

instance Term Xs'pattern where
    explode (x::Xs'pattern) = TermRep (toDyn x, f x, g x) where
	f (Xs'pattern aa ab) = [explode aa,explode ab]
	g (Xs'pattern _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'pattern (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'pattern)

_tc_Xs'patternTc = mkTyCon "Xs'pattern"
instance Typeable Xs'pattern where
    typeOf x = mkTyConApp _tc_Xs'patternTc [ ]

instance Term Xs'pattern_Attrs where
    explode (x::Xs'pattern_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'pattern_Attrs aa) = [explode aa]
	g (Xs'pattern_Attrs _) xs = case TermRep.fArgs xs of [aa] -> toDyn ((Xs'pattern_Attrs (TermRep.fDyn aa))::Xs'pattern_Attrs)

_tc_Xs'pattern_AttrsTc = mkTyCon "Xs'pattern_Attrs"
instance Typeable Xs'pattern_Attrs where
    typeOf x = mkTyConApp _tc_Xs'pattern_AttrsTc [ ]

instance Term Xs'encoding where
    explode (x::Xs'encoding) = TermRep (toDyn x, f x, g x) where
	f (Xs'encoding aa ab) = [explode aa,explode ab]
	g (Xs'encoding _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'encoding (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'encoding)

_tc_Xs'encodingTc = mkTyCon "Xs'encoding"
instance Typeable Xs'encoding where
    typeOf x = mkTyConApp _tc_Xs'encodingTc [ ]

instance Term Xs'encoding_Attrs where
    explode (x::Xs'encoding_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'encoding_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'encoding_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'encoding_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'encoding_Attrs)

_tc_Xs'encoding_AttrsTc = mkTyCon "Xs'encoding_Attrs"
instance Typeable Xs'encoding_Attrs where
    typeOf x = mkTyConApp _tc_Xs'encoding_AttrsTc [ ]

instance Term Xs'encoding_fixed where
    explode (x::Xs'encoding_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'encoding_fixed_true = []
	f Xs'encoding_fixed_false = []
	g Xs'encoding_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'encoding_fixed_true)::Xs'encoding_fixed)
	g Xs'encoding_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'encoding_fixed_false)::Xs'encoding_fixed)

_tc_Xs'encoding_fixedTc = mkTyCon "Xs'encoding_fixed"
instance Typeable Xs'encoding_fixed where
    typeOf x = mkTyConApp _tc_Xs'encoding_fixedTc [ ]

instance Term Xs'period where
    explode (x::Xs'period) = TermRep (toDyn x, f x, g x) where
	f (Xs'period aa ab) = [explode aa,explode ab]
	g (Xs'period _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'period (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'period)

_tc_Xs'periodTc = mkTyCon "Xs'period"
instance Typeable Xs'period where
    typeOf x = mkTyConApp _tc_Xs'periodTc [ ]

instance Term Xs'period_Attrs where
    explode (x::Xs'period_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'period_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'period_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'period_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'period_Attrs)

_tc_Xs'period_AttrsTc = mkTyCon "Xs'period_Attrs"
instance Typeable Xs'period_Attrs where
    typeOf x = mkTyConApp _tc_Xs'period_AttrsTc [ ]

instance Term Xs'period_fixed where
    explode (x::Xs'period_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'period_fixed_true = []
	f Xs'period_fixed_false = []
	g Xs'period_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'period_fixed_true)::Xs'period_fixed)
	g Xs'period_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'period_fixed_false)::Xs'period_fixed)

_tc_Xs'period_fixedTc = mkTyCon "Xs'period_fixed"
instance Typeable Xs'period_fixed where
    typeOf x = mkTyConApp _tc_Xs'period_fixedTc [ ]

instance Term Xs'duration where
    explode (x::Xs'duration) = TermRep (toDyn x, f x, g x) where
	f (Xs'duration aa ab) = [explode aa,explode ab]
	g (Xs'duration _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'duration (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'duration)

_tc_Xs'durationTc = mkTyCon "Xs'duration"
instance Typeable Xs'duration where
    typeOf x = mkTyConApp _tc_Xs'durationTc [ ]

instance Term Xs'duration_Attrs where
    explode (x::Xs'duration_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'duration_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'duration_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'duration_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'duration_Attrs)

_tc_Xs'duration_AttrsTc = mkTyCon "Xs'duration_Attrs"
instance Typeable Xs'duration_Attrs where
    typeOf x = mkTyConApp _tc_Xs'duration_AttrsTc [ ]

instance Term Xs'duration_fixed where
    explode (x::Xs'duration_fixed) = TermRep (toDyn x, f x, g x) where
	f Xs'duration_fixed_true = []
	f Xs'duration_fixed_false = []
	g Xs'duration_fixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'duration_fixed_true)::Xs'duration_fixed)
	g Xs'duration_fixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'duration_fixed_false)::Xs'duration_fixed)

_tc_Xs'duration_fixedTc = mkTyCon "Xs'duration_fixed"
instance Typeable Xs'duration_fixed where
    typeOf x = mkTyConApp _tc_Xs'duration_fixedTc [ ]

instance Term Xs'schema where
    explode (x::Xs'schema) = TermRep (toDyn x, f x, g x) where
	f (Xs'schema aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'schema _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'schema (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'schema)

_tc_Xs'schemaTc = mkTyCon "Xs'schema"
instance Typeable Xs'schema where
    typeOf x = mkTyConApp _tc_Xs'schemaTc [ ]

instance Term Xs'schema_Attrs where
    explode (x::Xs'schema_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'schema_Attrs aa ab ac ad ae af ag ah ai aj) = [explode aa,explode ab,explode ac,explode ad,explode ae,explode af,explode ag,explode ah,explode ai,explode aj]
	g (Xs'schema_Attrs _ _ _ _ _ _ _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad,ae,af,ag,ah,ai,aj] -> toDyn ((Xs'schema_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad) (TermRep.fDyn ae) (TermRep.fDyn af) (TermRep.fDyn ag) (TermRep.fDyn ah) (TermRep.fDyn ai) (TermRep.fDyn aj))::Xs'schema_Attrs)

_tc_Xs'schema_AttrsTc = mkTyCon "Xs'schema_Attrs"
instance Typeable Xs'schema_Attrs where
    typeOf x = mkTyConApp _tc_Xs'schema_AttrsTc [ ]

instance Term Xs'schema_elementFormDefault where
    explode (x::Xs'schema_elementFormDefault) = TermRep (toDyn x, f x, g x) where
	f Xs'schema_elementFormDefault_qualified = []
	f Xs'schema_elementFormDefault_unqualified = []
	g Xs'schema_elementFormDefault_qualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'schema_elementFormDefault_qualified)::Xs'schema_elementFormDefault)
	g Xs'schema_elementFormDefault_unqualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'schema_elementFormDefault_unqualified)::Xs'schema_elementFormDefault)

_tc_Xs'schema_elementFormDefaultTc = mkTyCon "Xs'schema_elementFormDefault"
instance Typeable Xs'schema_elementFormDefault where
    typeOf x = mkTyConApp _tc_Xs'schema_elementFormDefaultTc [ ]

instance Term Xs'schema_attributeFormDefault where
    explode (x::Xs'schema_attributeFormDefault) = TermRep (toDyn x, f x, g x) where
	f Xs'schema_attributeFormDefault_qualified = []
	f Xs'schema_attributeFormDefault_unqualified = []
	g Xs'schema_attributeFormDefault_qualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'schema_attributeFormDefault_qualified)::Xs'schema_attributeFormDefault)
	g Xs'schema_attributeFormDefault_unqualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'schema_attributeFormDefault_unqualified)::Xs'schema_attributeFormDefault)

_tc_Xs'schema_attributeFormDefaultTc = mkTyCon "Xs'schema_attributeFormDefault"
instance Typeable Xs'schema_attributeFormDefault where
    typeOf x = mkTyConApp _tc_Xs'schema_attributeFormDefaultTc [ ]

instance Term Xs'complexType where
    explode (x::Xs'complexType) = TermRep (toDyn x, f x, g x) where
	f (Xs'complexType aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'complexType _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'complexType (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'complexType)

_tc_Xs'complexTypeTc = mkTyCon "Xs'complexType"
instance Typeable Xs'complexType where
    typeOf x = mkTyConApp _tc_Xs'complexTypeTc [ ]

instance Term Xs'complexType_Attrs where
    explode (x::Xs'complexType_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'complexType_Attrs aa ab ac ad ae af) = [explode aa,explode ab,explode ac,explode ad,explode ae,explode af]
	g (Xs'complexType_Attrs _ _ _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad,ae,af] -> toDyn ((Xs'complexType_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad) (TermRep.fDyn ae) (TermRep.fDyn af))::Xs'complexType_Attrs)

_tc_Xs'complexType_AttrsTc = mkTyCon "Xs'complexType_Attrs"
instance Typeable Xs'complexType_Attrs where
    typeOf x = mkTyConApp _tc_Xs'complexType_AttrsTc [ ]

instance Term Xs'complexType_abstract where
    explode (x::Xs'complexType_abstract) = TermRep (toDyn x, f x, g x) where
	f Xs'complexType_abstract_true = []
	f Xs'complexType_abstract_false = []
	g Xs'complexType_abstract_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'complexType_abstract_true)::Xs'complexType_abstract)
	g Xs'complexType_abstract_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'complexType_abstract_false)::Xs'complexType_abstract)

_tc_Xs'complexType_abstractTc = mkTyCon "Xs'complexType_abstract"
instance Typeable Xs'complexType_abstract where
    typeOf x = mkTyConApp _tc_Xs'complexType_abstractTc [ ]

instance Term Xs'complexType_mixed where
    explode (x::Xs'complexType_mixed) = TermRep (toDyn x, f x, g x) where
	f Xs'complexType_mixed_true = []
	f Xs'complexType_mixed_false = []
	g Xs'complexType_mixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'complexType_mixed_true)::Xs'complexType_mixed)
	g Xs'complexType_mixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'complexType_mixed_false)::Xs'complexType_mixed)

_tc_Xs'complexType_mixedTc = mkTyCon "Xs'complexType_mixed"
instance Typeable Xs'complexType_mixed where
    typeOf x = mkTyConApp _tc_Xs'complexType_mixedTc [ ]

instance Term Xs'complexContent where
    explode (x::Xs'complexContent) = TermRep (toDyn x, f x, g x) where
	f (Xs'complexContent aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'complexContent _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'complexContent (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'complexContent)

_tc_Xs'complexContentTc = mkTyCon "Xs'complexContent"
instance Typeable Xs'complexContent where
    typeOf x = mkTyConApp _tc_Xs'complexContentTc [ ]

instance Term Xs'complexContent_Attrs where
    explode (x::Xs'complexContent_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'complexContent_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'complexContent_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'complexContent_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'complexContent_Attrs)

_tc_Xs'complexContent_AttrsTc = mkTyCon "Xs'complexContent_Attrs"
instance Typeable Xs'complexContent_Attrs where
    typeOf x = mkTyConApp _tc_Xs'complexContent_AttrsTc [ ]

instance Term Xs'complexContent_mixed where
    explode (x::Xs'complexContent_mixed) = TermRep (toDyn x, f x, g x) where
	f Xs'complexContent_mixed_true = []
	f Xs'complexContent_mixed_false = []
	g Xs'complexContent_mixed_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'complexContent_mixed_true)::Xs'complexContent_mixed)
	g Xs'complexContent_mixed_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'complexContent_mixed_false)::Xs'complexContent_mixed)

_tc_Xs'complexContent_mixedTc = mkTyCon "Xs'complexContent_mixed"
instance Typeable Xs'complexContent_mixed where
    typeOf x = mkTyConApp _tc_Xs'complexContent_mixedTc [ ]

instance Term Xs'simpleContent where
    explode (x::Xs'simpleContent) = TermRep (toDyn x, f x, g x) where
	f (Xs'simpleContent aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'simpleContent _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'simpleContent (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'simpleContent)

_tc_Xs'simpleContentTc = mkTyCon "Xs'simpleContent"
instance Typeable Xs'simpleContent where
    typeOf x = mkTyConApp _tc_Xs'simpleContentTc [ ]

instance Term Xs'simpleContent_Attrs where
    explode (x::Xs'simpleContent_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'simpleContent_Attrs aa) = [explode aa]
	g (Xs'simpleContent_Attrs _) xs = case TermRep.fArgs xs of [aa] -> toDyn ((Xs'simpleContent_Attrs (TermRep.fDyn aa))::Xs'simpleContent_Attrs)

_tc_Xs'simpleContent_AttrsTc = mkTyCon "Xs'simpleContent_Attrs"
instance Typeable Xs'simpleContent_Attrs where
    typeOf x = mkTyConApp _tc_Xs'simpleContent_AttrsTc [ ]

instance Term Xs'extension where
    explode (x::Xs'extension) = TermRep (toDyn x, f x, g x) where
	f (Xs'extension aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'extension _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'extension (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'extension)

_tc_Xs'extensionTc = mkTyCon "Xs'extension"
instance Typeable Xs'extension where
    typeOf x = mkTyConApp _tc_Xs'extensionTc [ ]

instance Term Xs'extension_Attrs where
    explode (x::Xs'extension_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'extension_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'extension_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'extension_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'extension_Attrs)

_tc_Xs'extension_AttrsTc = mkTyCon "Xs'extension_Attrs"
instance Typeable Xs'extension_Attrs where
    typeOf x = mkTyConApp _tc_Xs'extension_AttrsTc [ ]

instance Term Xs'element where
    explode (x::Xs'element) = TermRep (toDyn x, f x, g x) where
	f (Xs'element aa ab ac ad) = [explode aa,explode ab,explode ac,explode ad]
	g (Xs'element _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad] -> toDyn ((Xs'element (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad))::Xs'element)

_tc_Xs'elementTc = mkTyCon "Xs'element"
instance Typeable Xs'element where
    typeOf x = mkTyConApp _tc_Xs'elementTc [ ]

instance Term Xs'element_Attrs where
    explode (x::Xs'element_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'element_Attrs aa ab ac ad ae af ag ah ai aj ak al am an) = [explode aa,explode ab,explode ac,explode ad,explode ae,explode af,explode ag,explode ah,explode ai,explode aj,explode ak,explode al,explode am,explode an]
	g (Xs'element_Attrs _ _ _ _ _ _ _ _ _ _ _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an] -> toDyn ((Xs'element_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad) (TermRep.fDyn ae) (TermRep.fDyn af) (TermRep.fDyn ag) (TermRep.fDyn ah) (TermRep.fDyn ai) (TermRep.fDyn aj) (TermRep.fDyn ak) (TermRep.fDyn al) (TermRep.fDyn am) (TermRep.fDyn an))::Xs'element_Attrs)

_tc_Xs'element_AttrsTc = mkTyCon "Xs'element_Attrs"
instance Typeable Xs'element_Attrs where
    typeOf x = mkTyConApp _tc_Xs'element_AttrsTc [ ]

instance Term Xs'element_nillable where
    explode (x::Xs'element_nillable) = TermRep (toDyn x, f x, g x) where
	f Xs'element_nillable_true = []
	f Xs'element_nillable_false = []
	g Xs'element_nillable_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'element_nillable_true)::Xs'element_nillable)
	g Xs'element_nillable_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'element_nillable_false)::Xs'element_nillable)

_tc_Xs'element_nillableTc = mkTyCon "Xs'element_nillable"
instance Typeable Xs'element_nillable where
    typeOf x = mkTyConApp _tc_Xs'element_nillableTc [ ]

instance Term Xs'element_abstract where
    explode (x::Xs'element_abstract) = TermRep (toDyn x, f x, g x) where
	f Xs'element_abstract_true = []
	f Xs'element_abstract_false = []
	g Xs'element_abstract_true xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'element_abstract_true)::Xs'element_abstract)
	g Xs'element_abstract_false xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'element_abstract_false)::Xs'element_abstract)

_tc_Xs'element_abstractTc = mkTyCon "Xs'element_abstract"
instance Typeable Xs'element_abstract where
    typeOf x = mkTyConApp _tc_Xs'element_abstractTc [ ]

instance Term Xs'element_form where
    explode (x::Xs'element_form) = TermRep (toDyn x, f x, g x) where
	f Xs'element_form_qualified = []
	f Xs'element_form_unqualified = []
	g Xs'element_form_qualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'element_form_qualified)::Xs'element_form)
	g Xs'element_form_unqualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'element_form_unqualified)::Xs'element_form)

_tc_Xs'element_formTc = mkTyCon "Xs'element_form"
instance Typeable Xs'element_form where
    typeOf x = mkTyConApp _tc_Xs'element_formTc [ ]

instance Term Xs'group where
    explode (x::Xs'group) = TermRep (toDyn x, f x, g x) where
	f (Xs'group aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'group _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'group (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'group)

_tc_Xs'groupTc = mkTyCon "Xs'group"
instance Typeable Xs'group where
    typeOf x = mkTyConApp _tc_Xs'groupTc [ ]

instance Term Xs'group_Attrs where
    explode (x::Xs'group_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'group_Attrs aa ab ac ad ae) = [explode aa,explode ab,explode ac,explode ad,explode ae]
	g (Xs'group_Attrs _ _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad,ae] -> toDyn ((Xs'group_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad) (TermRep.fDyn ae))::Xs'group_Attrs)

_tc_Xs'group_AttrsTc = mkTyCon "Xs'group_Attrs"
instance Typeable Xs'group_Attrs where
    typeOf x = mkTyConApp _tc_Xs'group_AttrsTc [ ]

instance Term Xs'all where
    explode (x::Xs'all) = TermRep (toDyn x, f x, g x) where
	f (Xs'all aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'all _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'all (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'all)

_tc_Xs'allTc = mkTyCon "Xs'all"
instance Typeable Xs'all where
    typeOf x = mkTyConApp _tc_Xs'allTc [ ]

instance Term Xs'all_Attrs where
    explode (x::Xs'all_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'all_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'all_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'all_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'all_Attrs)

_tc_Xs'all_AttrsTc = mkTyCon "Xs'all_Attrs"
instance Typeable Xs'all_Attrs where
    typeOf x = mkTyConApp _tc_Xs'all_AttrsTc [ ]

instance Term Xs'all_minOccurs where
    explode (x::Xs'all_minOccurs) = TermRep (toDyn x, f x, g x) where
	f Xs'all_minOccurs_1 = []
	g Xs'all_minOccurs_1 xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'all_minOccurs_1)::Xs'all_minOccurs)

_tc_Xs'all_minOccursTc = mkTyCon "Xs'all_minOccurs"
instance Typeable Xs'all_minOccurs where
    typeOf x = mkTyConApp _tc_Xs'all_minOccursTc [ ]

instance Term Xs'all_maxOccurs where
    explode (x::Xs'all_maxOccurs) = TermRep (toDyn x, f x, g x) where
	f Xs'all_maxOccurs_1 = []
	g Xs'all_maxOccurs_1 xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'all_maxOccurs_1)::Xs'all_maxOccurs)

_tc_Xs'all_maxOccursTc = mkTyCon "Xs'all_maxOccurs"
instance Typeable Xs'all_maxOccurs where
    typeOf x = mkTyConApp _tc_Xs'all_maxOccursTc [ ]

instance Term Xs'choice where
    explode (x::Xs'choice) = TermRep (toDyn x, f x, g x) where
	f (Xs'choice aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'choice _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'choice (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'choice)

_tc_Xs'choiceTc = mkTyCon "Xs'choice"
instance Typeable Xs'choice where
    typeOf x = mkTyConApp _tc_Xs'choiceTc [ ]

instance Term Xs'choice_Attrs where
    explode (x::Xs'choice_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'choice_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'choice_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'choice_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'choice_Attrs)

_tc_Xs'choice_AttrsTc = mkTyCon "Xs'choice_Attrs"
instance Typeable Xs'choice_Attrs where
    typeOf x = mkTyConApp _tc_Xs'choice_AttrsTc [ ]

instance Term Xs'sequence where
    explode (x::Xs'sequence) = TermRep (toDyn x, f x, g x) where
	f (Xs'sequence aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'sequence _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'sequence (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'sequence)

_tc_Xs'sequenceTc = mkTyCon "Xs'sequence"
instance Typeable Xs'sequence where
    typeOf x = mkTyConApp _tc_Xs'sequenceTc [ ]

instance Term Xs'sequence_Attrs where
    explode (x::Xs'sequence_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'sequence_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'sequence_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'sequence_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'sequence_Attrs)

_tc_Xs'sequence_AttrsTc = mkTyCon "Xs'sequence_Attrs"
instance Typeable Xs'sequence_Attrs where
    typeOf x = mkTyConApp _tc_Xs'sequence_AttrsTc [ ]

instance Term Xs'any where
    explode (x::Xs'any) = TermRep (toDyn x, f x, g x) where
	f (Xs'any aa ab) = [explode aa,explode ab]
	g (Xs'any _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'any (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'any)

_tc_Xs'anyTc = mkTyCon "Xs'any"
instance Typeable Xs'any where
    typeOf x = mkTyConApp _tc_Xs'anyTc [ ]

instance Term Xs'any_Attrs where
    explode (x::Xs'any_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'any_Attrs aa ab ac ad ae) = [explode aa,explode ab,explode ac,explode ad,explode ae]
	g (Xs'any_Attrs _ _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad,ae] -> toDyn ((Xs'any_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad) (TermRep.fDyn ae))::Xs'any_Attrs)

_tc_Xs'any_AttrsTc = mkTyCon "Xs'any_Attrs"
instance Typeable Xs'any_Attrs where
    typeOf x = mkTyConApp _tc_Xs'any_AttrsTc [ ]

instance Term Xs'any_processContents where
    explode (x::Xs'any_processContents) = TermRep (toDyn x, f x, g x) where
	f Xs'any_processContents_skip = []
	f Xs'any_processContents_lax = []
	f Xs'any_processContents_strict = []
	g Xs'any_processContents_skip xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'any_processContents_skip)::Xs'any_processContents)
	g Xs'any_processContents_lax xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'any_processContents_lax)::Xs'any_processContents)
	g Xs'any_processContents_strict xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'any_processContents_strict)::Xs'any_processContents)

_tc_Xs'any_processContentsTc = mkTyCon "Xs'any_processContents"
instance Typeable Xs'any_processContents where
    typeOf x = mkTyConApp _tc_Xs'any_processContentsTc [ ]

instance Term Xs'anyAttribute where
    explode (x::Xs'anyAttribute) = TermRep (toDyn x, f x, g x) where
	f (Xs'anyAttribute aa ab) = [explode aa,explode ab]
	g (Xs'anyAttribute _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'anyAttribute (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'anyAttribute)

_tc_Xs'anyAttributeTc = mkTyCon "Xs'anyAttribute"
instance Typeable Xs'anyAttribute where
    typeOf x = mkTyConApp _tc_Xs'anyAttributeTc [ ]

instance Term Xs'anyAttribute_Attrs where
    explode (x::Xs'anyAttribute_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'anyAttribute_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'anyAttribute_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'anyAttribute_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'anyAttribute_Attrs)

_tc_Xs'anyAttribute_AttrsTc = mkTyCon "Xs'anyAttribute_Attrs"
instance Typeable Xs'anyAttribute_Attrs where
    typeOf x = mkTyConApp _tc_Xs'anyAttribute_AttrsTc [ ]

instance Term Xs'anyAttribute_processContents where
    explode (x::Xs'anyAttribute_processContents) = TermRep (toDyn x, f x, g x) where
	f Xs'anyAttribute_processContents_skip = []
	f Xs'anyAttribute_processContents_lax = []
	f Xs'anyAttribute_processContents_strict = []
	g Xs'anyAttribute_processContents_skip xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'anyAttribute_processContents_skip)::Xs'anyAttribute_processContents)
	g Xs'anyAttribute_processContents_lax xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'anyAttribute_processContents_lax)::Xs'anyAttribute_processContents)
	g Xs'anyAttribute_processContents_strict xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'anyAttribute_processContents_strict)::Xs'anyAttribute_processContents)

_tc_Xs'anyAttribute_processContentsTc = mkTyCon "Xs'anyAttribute_processContents"
instance Typeable Xs'anyAttribute_processContents where
    typeOf x = mkTyConApp _tc_Xs'anyAttribute_processContentsTc [ ]

instance Term Xs'attribute where
    explode (x::Xs'attribute) = TermRep (toDyn x, f x, g x) where
	f (Xs'attribute aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'attribute _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'attribute (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'attribute)

_tc_Xs'attributeTc = mkTyCon "Xs'attribute"
instance Typeable Xs'attribute where
    typeOf x = mkTyConApp _tc_Xs'attributeTc [ ]

instance Term Xs'attribute_Attrs where
    explode (x::Xs'attribute_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'attribute_Attrs aa ab ac ad ae af ag ah) = [explode aa,explode ab,explode ac,explode ad,explode ae,explode af,explode ag,explode ah]
	g (Xs'attribute_Attrs _ _ _ _ _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad,ae,af,ag,ah] -> toDyn ((Xs'attribute_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad) (TermRep.fDyn ae) (TermRep.fDyn af) (TermRep.fDyn ag) (TermRep.fDyn ah))::Xs'attribute_Attrs)

_tc_Xs'attribute_AttrsTc = mkTyCon "Xs'attribute_Attrs"
instance Typeable Xs'attribute_Attrs where
    typeOf x = mkTyConApp _tc_Xs'attribute_AttrsTc [ ]

instance Term Xs'attribute_use where
    explode (x::Xs'attribute_use) = TermRep (toDyn x, f x, g x) where
	f Xs'attribute_use_prohibited = []
	f Xs'attribute_use_optional = []
	f Xs'attribute_use_required = []
	g Xs'attribute_use_prohibited xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'attribute_use_prohibited)::Xs'attribute_use)
	g Xs'attribute_use_optional xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'attribute_use_optional)::Xs'attribute_use)
	g Xs'attribute_use_required xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'attribute_use_required)::Xs'attribute_use)

_tc_Xs'attribute_useTc = mkTyCon "Xs'attribute_use"
instance Typeable Xs'attribute_use where
    typeOf x = mkTyConApp _tc_Xs'attribute_useTc [ ]

instance Term Xs'attribute_form where
    explode (x::Xs'attribute_form) = TermRep (toDyn x, f x, g x) where
	f Xs'attribute_form_qualified = []
	f Xs'attribute_form_unqualified = []
	g Xs'attribute_form_qualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'attribute_form_qualified)::Xs'attribute_form)
	g Xs'attribute_form_unqualified xs = case TermRep.fArgs xs of [] -> toDyn ((Xs'attribute_form_unqualified)::Xs'attribute_form)

_tc_Xs'attribute_formTc = mkTyCon "Xs'attribute_form"
instance Typeable Xs'attribute_form where
    typeOf x = mkTyConApp _tc_Xs'attribute_formTc [ ]

instance Term Xs'attributeGroup where
    explode (x::Xs'attributeGroup) = TermRep (toDyn x, f x, g x) where
	f (Xs'attributeGroup aa ab ac ad) = [explode aa,explode ab,explode ac,explode ad]
	g (Xs'attributeGroup _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad] -> toDyn ((Xs'attributeGroup (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad))::Xs'attributeGroup)

_tc_Xs'attributeGroupTc = mkTyCon "Xs'attributeGroup"
instance Typeable Xs'attributeGroup where
    typeOf x = mkTyConApp _tc_Xs'attributeGroupTc [ ]

instance Term Xs'attributeGroup_Attrs where
    explode (x::Xs'attributeGroup_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'attributeGroup_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'attributeGroup_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'attributeGroup_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'attributeGroup_Attrs)

_tc_Xs'attributeGroup_AttrsTc = mkTyCon "Xs'attributeGroup_Attrs"
instance Typeable Xs'attributeGroup_Attrs where
    typeOf x = mkTyConApp _tc_Xs'attributeGroup_AttrsTc [ ]

instance Term Xs'unique where
    explode (x::Xs'unique) = TermRep (toDyn x, f x, g x) where
	f (Xs'unique aa ab ac ad) = [explode aa,explode ab,explode ac,explode ad]
	g (Xs'unique _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad] -> toDyn ((Xs'unique (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad))::Xs'unique)

_tc_Xs'uniqueTc = mkTyCon "Xs'unique"
instance Typeable Xs'unique where
    typeOf x = mkTyConApp _tc_Xs'uniqueTc [ ]

instance Term Xs'unique_Attrs where
    explode (x::Xs'unique_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'unique_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'unique_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'unique_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'unique_Attrs)

_tc_Xs'unique_AttrsTc = mkTyCon "Xs'unique_Attrs"
instance Typeable Xs'unique_Attrs where
    typeOf x = mkTyConApp _tc_Xs'unique_AttrsTc [ ]

instance Term Xs'key where
    explode (x::Xs'key) = TermRep (toDyn x, f x, g x) where
	f (Xs'key aa ab ac ad) = [explode aa,explode ab,explode ac,explode ad]
	g (Xs'key _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad] -> toDyn ((Xs'key (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad))::Xs'key)

_tc_Xs'keyTc = mkTyCon "Xs'key"
instance Typeable Xs'key where
    typeOf x = mkTyConApp _tc_Xs'keyTc [ ]

instance Term Xs'key_Attrs where
    explode (x::Xs'key_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'key_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'key_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'key_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'key_Attrs)

_tc_Xs'key_AttrsTc = mkTyCon "Xs'key_Attrs"
instance Typeable Xs'key_Attrs where
    typeOf x = mkTyConApp _tc_Xs'key_AttrsTc [ ]

instance Term Xs'keyref where
    explode (x::Xs'keyref) = TermRep (toDyn x, f x, g x) where
	f (Xs'keyref aa ab ac ad) = [explode aa,explode ab,explode ac,explode ad]
	g (Xs'keyref _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad] -> toDyn ((Xs'keyref (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad))::Xs'keyref)

_tc_Xs'keyrefTc = mkTyCon "Xs'keyref"
instance Typeable Xs'keyref where
    typeOf x = mkTyConApp _tc_Xs'keyrefTc [ ]

instance Term Xs'keyref_Attrs where
    explode (x::Xs'keyref_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'keyref_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'keyref_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'keyref_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'keyref_Attrs)

_tc_Xs'keyref_AttrsTc = mkTyCon "Xs'keyref_Attrs"
instance Typeable Xs'keyref_Attrs where
    typeOf x = mkTyConApp _tc_Xs'keyref_AttrsTc [ ]

instance Term Xs'selector where
    explode (x::Xs'selector) = TermRep (toDyn x, f x, g x) where
	f (Xs'selector aa ab) = [explode aa,explode ab]
	g (Xs'selector _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'selector (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'selector)

_tc_Xs'selectorTc = mkTyCon "Xs'selector"
instance Typeable Xs'selector where
    typeOf x = mkTyConApp _tc_Xs'selectorTc [ ]

instance Term Xs'selector_Attrs where
    explode (x::Xs'selector_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'selector_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'selector_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'selector_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'selector_Attrs)

_tc_Xs'selector_AttrsTc = mkTyCon "Xs'selector_Attrs"
instance Typeable Xs'selector_Attrs where
    typeOf x = mkTyConApp _tc_Xs'selector_AttrsTc [ ]

instance Term Xs'field where
    explode (x::Xs'field) = TermRep (toDyn x, f x, g x) where
	f (Xs'field aa ab) = [explode aa,explode ab]
	g (Xs'field _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'field (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'field)

_tc_Xs'fieldTc = mkTyCon "Xs'field"
instance Typeable Xs'field where
    typeOf x = mkTyConApp _tc_Xs'fieldTc [ ]

instance Term Xs'field_Attrs where
    explode (x::Xs'field_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'field_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'field_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'field_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'field_Attrs)

_tc_Xs'field_AttrsTc = mkTyCon "Xs'field_Attrs"
instance Typeable Xs'field_Attrs where
    typeOf x = mkTyConApp _tc_Xs'field_AttrsTc [ ]

instance Term Xs'include where
    explode (x::Xs'include) = TermRep (toDyn x, f x, g x) where
	f (Xs'include aa ab) = [explode aa,explode ab]
	g (Xs'include _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'include (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'include)

_tc_Xs'includeTc = mkTyCon "Xs'include"
instance Typeable Xs'include where
    typeOf x = mkTyConApp _tc_Xs'includeTc [ ]

instance Term Xs'include_Attrs where
    explode (x::Xs'include_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'include_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'include_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'include_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'include_Attrs)

_tc_Xs'include_AttrsTc = mkTyCon "Xs'include_Attrs"
instance Typeable Xs'include_Attrs where
    typeOf x = mkTyConApp _tc_Xs'include_AttrsTc [ ]

instance Term Xs'import where
    explode (x::Xs'import) = TermRep (toDyn x, f x, g x) where
	f (Xs'import aa ab) = [explode aa,explode ab]
	g (Xs'import _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'import (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'import)

_tc_Xs'importTc = mkTyCon "Xs'import"
instance Typeable Xs'import where
    typeOf x = mkTyConApp _tc_Xs'importTc [ ]

instance Term Xs'import_Attrs where
    explode (x::Xs'import_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'import_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'import_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'import_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'import_Attrs)

_tc_Xs'import_AttrsTc = mkTyCon "Xs'import_Attrs"
instance Typeable Xs'import_Attrs where
    typeOf x = mkTyConApp _tc_Xs'import_AttrsTc [ ]

instance Term Xs'redefine where
    explode (x::Xs'redefine) = TermRep (toDyn x, f x, g x) where
	f (Xs'redefine aa ab) = [explode aa,explode ab]
	g (Xs'redefine _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'redefine (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'redefine)

_tc_Xs'redefineTc = mkTyCon "Xs'redefine"
instance Typeable Xs'redefine where
    typeOf x = mkTyConApp _tc_Xs'redefineTc [ ]

instance Term Xs'redefine_Attrs where
    explode (x::Xs'redefine_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'redefine_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'redefine_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'redefine_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'redefine_Attrs)

_tc_Xs'redefine_AttrsTc = mkTyCon "Xs'redefine_Attrs"
instance Typeable Xs'redefine_Attrs where
    typeOf x = mkTyConApp _tc_Xs'redefine_AttrsTc [ ]

instance Term Xs'redefine_ where
    explode (x::Xs'redefine_) = TermRep (toDyn x, f x, g x) where
	f (Xs'redefine_Xs'annotation aa) = [explode aa]
	f (Xs'redefine_Xs'simpleType ab) = [explode ab]
	f (Xs'redefine_Xs'complexType ac) = [explode ac]
	f (Xs'redefine_Xs'attributeGroup ad) = [explode ad]
	f (Xs'redefine_Xs'group ae) = [explode ae]
	g (Xs'redefine_Xs'annotation _) xs = case TermRep.fArgs xs of [aa] -> toDyn ((Xs'redefine_Xs'annotation (TermRep.fDyn aa))::Xs'redefine_)
	g (Xs'redefine_Xs'simpleType _) xs = case TermRep.fArgs xs of [ab] -> toDyn ((Xs'redefine_Xs'simpleType (TermRep.fDyn ab))::Xs'redefine_)
	g (Xs'redefine_Xs'complexType _) xs = case TermRep.fArgs xs of [ac] -> toDyn ((Xs'redefine_Xs'complexType (TermRep.fDyn ac))::Xs'redefine_)
	g (Xs'redefine_Xs'attributeGroup _) xs = case TermRep.fArgs xs of [ad] -> toDyn ((Xs'redefine_Xs'attributeGroup (TermRep.fDyn ad))::Xs'redefine_)
	g (Xs'redefine_Xs'group _) xs = case TermRep.fArgs xs of [ae] -> toDyn ((Xs'redefine_Xs'group (TermRep.fDyn ae))::Xs'redefine_)

_tc_Xs'redefine_Tc = mkTyCon "Xs'redefine_"
instance Typeable Xs'redefine_ where
    typeOf x = mkTyConApp _tc_Xs'redefine_Tc [ ]

instance Term Xs'notation where
    explode (x::Xs'notation) = TermRep (toDyn x, f x, g x) where
	f (Xs'notation aa ab) = [explode aa,explode ab]
	g (Xs'notation _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'notation (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'notation)

_tc_Xs'notationTc = mkTyCon "Xs'notation"
instance Typeable Xs'notation where
    typeOf x = mkTyConApp _tc_Xs'notationTc [ ]

instance Term Xs'notation_Attrs where
    explode (x::Xs'notation_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'notation_Attrs aa ab ac ad) = [explode aa,explode ab,explode ac,explode ad]
	g (Xs'notation_Attrs _ _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac,ad] -> toDyn ((Xs'notation_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac) (TermRep.fDyn ad))::Xs'notation_Attrs)

_tc_Xs'notation_AttrsTc = mkTyCon "Xs'notation_Attrs"
instance Typeable Xs'notation_Attrs where
    typeOf x = mkTyConApp _tc_Xs'notation_AttrsTc [ ]

instance Term Xs'annotation where
    explode (x::Xs'annotation) = TermRep (toDyn x, f x, g x) where
	f (Xs'annotation aa) = [explode aa]
	g (Xs'annotation _) xs = case TermRep.fArgs xs of [aa] -> toDyn ((Xs'annotation (TermRep.fDyn aa))::Xs'annotation)

_tc_Xs'annotationTc = mkTyCon "Xs'annotation"
instance Typeable Xs'annotation where
    typeOf x = mkTyConApp _tc_Xs'annotationTc [ ]

instance Term Xs'annotation_ where
    explode (x::Xs'annotation_) = TermRep (toDyn x, f x, g x) where
	f (Xs'annotation_Xs'appinfo aa) = [explode aa]
	f (Xs'annotation_Xs'documentation ab) = [explode ab]
	g (Xs'annotation_Xs'appinfo _) xs = case TermRep.fArgs xs of [aa] -> toDyn ((Xs'annotation_Xs'appinfo (TermRep.fDyn aa))::Xs'annotation_)
	g (Xs'annotation_Xs'documentation _) xs = case TermRep.fArgs xs of [ab] -> toDyn ((Xs'annotation_Xs'documentation (TermRep.fDyn ab))::Xs'annotation_)

_tc_Xs'annotation_Tc = mkTyCon "Xs'annotation_"
instance Typeable Xs'annotation_ where
    typeOf x = mkTyConApp _tc_Xs'annotation_Tc [ ]

instance Term Xs'appinfo where
    explode (x::Xs'appinfo) = TermRep (toDyn x, f x, g x) where
	f (Xs'appinfo aa ab) = [explode aa,explode ab]
	g (Xs'appinfo _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'appinfo (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'appinfo)

_tc_Xs'appinfoTc = mkTyCon "Xs'appinfo"
instance Typeable Xs'appinfo where
    typeOf x = mkTyConApp _tc_Xs'appinfoTc [ ]

instance Term Xs'appinfo_Attrs where
    explode (x::Xs'appinfo_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'appinfo_Attrs aa ab) = [explode aa,explode ab]
	g (Xs'appinfo_Attrs _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'appinfo_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'appinfo_Attrs)

_tc_Xs'appinfo_AttrsTc = mkTyCon "Xs'appinfo_Attrs"
instance Typeable Xs'appinfo_Attrs where
    typeOf x = mkTyConApp _tc_Xs'appinfo_AttrsTc [ ]

instance Term Xs'documentation where
    explode (x::Xs'documentation) = TermRep (toDyn x, f x, g x) where
	f (Xs'documentation aa ab) = [explode aa,explode ab]
	g (Xs'documentation _ _) xs = case TermRep.fArgs xs of [aa,ab] -> toDyn ((Xs'documentation (TermRep.fDyn aa) (TermRep.fDyn ab))::Xs'documentation)

_tc_Xs'documentationTc = mkTyCon "Xs'documentation"
instance Typeable Xs'documentation where
    typeOf x = mkTyConApp _tc_Xs'documentationTc [ ]

instance Term Xs'documentation_Attrs where
    explode (x::Xs'documentation_Attrs) = TermRep (toDyn x, f x, g x) where
	f (Xs'documentation_Attrs aa ab ac) = [explode aa,explode ab,explode ac]
	g (Xs'documentation_Attrs _ _ _) xs = case TermRep.fArgs xs of [aa,ab,ac] -> toDyn ((Xs'documentation_Attrs (TermRep.fDyn aa) (TermRep.fDyn ab) (TermRep.fDyn ac))::Xs'documentation_Attrs)

_tc_Xs'documentation_AttrsTc = mkTyCon "Xs'documentation_Attrs"
instance Typeable Xs'documentation_Attrs where
    typeOf x = mkTyConApp _tc_Xs'documentation_AttrsTc [ ]

--  Imported from other files :-

